{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XJCjHC1Cig3c"
   },
   "source": [
    "# [Evaluating AI Search Engines with `judges` - the open-source library for LLM-as-a-judge evaluators ⚖️](#evaluating-ai-search-engines-with-judges---the-open-source-library-for-llm-as-a-judge-evaluators-)\n",
    "\n",
    "*Authored by: [James Liounis](https://github.com/jamesliounis)*\n",
    "\n",
    "---\n",
    "\n",
    "### Table of Contents  \n",
    "\n",
    "1. [Evaluating AI Search Engines with `judges` - the open-source library for LLM-as-a-judge evaluators ⚖️](#evaluating-ai-search-engines-with-judges---the-open-source-library-for-llm-as-a-judge-evaluators-)  \n",
    "2. [Setup](#setup)  \n",
    "3. [🔍🤖 Generating Answers with AI Search Engines](#-generating-answers-with-ai-search-engines)  \n",
    "   - [🧠 Perplexity](#-perplexity)  \n",
    "   - [🌟 Gemini](#-gemini)  \n",
    "   - [🤖 Exa AI](#-exa-ai)  \n",
    "4. [⚖️🔍 Using `judges` to Evaluate Search Results](#-using-judges-to-evaluate-search-results)  \n",
    "5. [⚖️🚀 Getting Started with `judges`](#getting-started-with-judges-)  \n",
    "   - [Choosing a model](#choosing-a-model)  \n",
    "   - [Running an Evaluation on a Single Datapoint](#running-an-evaluation-on-a-single-datapoint)  \n",
    "6. [⚖️🛠️ Choosing the Right `judge`](#-choosing-the-right-judge)  \n",
    "   - [PollMultihopCorrectness (Correctness Classifier)](#1-pollmultihopcorrectness-correctness-classifier)\n",
    "   - [PrometheusAbsoluteCoarseCorrectness (Correctness Grader)](#2-prometheusabsolutecoarsecorrectness-correctness-grader)\n",
    "   - [MTBenchChatBotResponseQuality (Response Quality Evaluation)](#3-mtbenchchatbotresponsequality-response-quality-evaluation)  \n",
    "7. [⚙️🎯 Evaluation](#-evaluation)\n",
    "8. [🥇 Results](#-results)  \n",
    "9. [🧙‍♂️✅ Conclusion](#-conclusion)  \n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**[`judges`](https://github.com/quotient-ai/judges)** is an open-sources library to use and create LLM-as-a-Judge evaluators. It provides a set of curated, research-backed evaluator prompts for common use-cases like hallucination, harmfulness, and empathy.\n",
    "\n",
    "The `judges` library is available on [GitHub](https://github.com/quotient-ai/judges) or via `pip install judges`.\n",
    "\n",
    "In this notebook, we show how `judges` can be used to evaluate and compare outputs from top AI search engines like Perplexity, EXA, and Gemini.\n",
    "\n",
    "---\n",
    "\n",
    "## [Setup](#setup)\n",
    "\n",
    "We use the [Natural Questions dataset](https://paperswithcode.com/dataset/natural-questions), an open-source collection of real Google queries and Wikipedia articles, to benchmark AI search engine quality.\n",
    "\n",
    "1. Start with a [**100-datapoint subset of Natural Questions**](https://huggingface.co/datasets/quotientai/labeled-natural-qa-random-100), which only includes human evaluated answers and their corresponding queries for correctness, clarity, and completeness. We'll use these as the ground truth answers to the queries.\n",
    "2. Use different **AI search engines** (Perplexity, Exa, and Gemini) to generate responses to the queries in the dataset.\n",
    "3. Use `judges` to evaluate the responses for **correctness** and **quality**.\n",
    "\n",
    "Let's dive in!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Rh3u8b6Hj_WV"
   },
   "outputs": [],
   "source": [
    "!pip install judges[litellm] datasets google-generativeai exa_py seaborn matplotlib --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pFMcWL7xj_WW",
    "outputId": "e2db549c-a4f7-445c-80f1-667da469a90d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "from IPython.display import Markdown, HTML\n",
    "from tqdm import tqdm\n",
    "\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "F-IXo8OXeS53",
    "outputId": "68fc4755-340a-4343-cd6b-9cc2997e12ee"
   },
   "outputs": [],
   "source": [
    "from huggingface_hub import notebook_login\n",
    "\n",
    "notebook_login()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hWW6wdPTdEW9"
   },
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "\n",
    "dataset = load_dataset(\"quotientai/labeled-natural-qa-random-100\")\n",
    "\n",
    "data = dataset['train'].to_pandas()\n",
    "data = data[data['label'] == 'good']\n",
    "\n",
    "data.head()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6NBl2u1Uxtv7"
   },
   "source": [
    "## [🔍🤖 Generating Answers with AI Search Engines](#-generating-answers-with-ai-search-engines)  \n",
    "\n",
    "Let's start by querying three AI search engines - Perplexity, EXA, and Gemini - with the queries from our 100-datapoint dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SWYaCZEPj_WX"
   },
   "source": [
    "You can either set the API keys from a `.env` file, such as what we are doing below.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jLDRrvUUx8K5"
   },
   "source": [
    "### 🌟 Gemini  \n",
    "\n",
    "To generate answers with **Gemini**, we tap into the Gemini API with the **grounding option**—in order to retrieve a well-grounded response based on a Google search. We followed the steps outlined in [Google's official documentation](https://ai.google.dev/gemini-api/docs/grounding?lang=python) to get started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_zh9xtlEj_WY"
   },
   "outputs": [],
   "source": [
    "GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')\n",
    "\n",
    "## Use this if using Colab\n",
    "#GOOGLE_API_KEY=userdata.get('GOOGLE_API_KEY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vp_rUQ7vmjvt"
   },
   "outputs": [],
   "source": [
    "# from google.colab import userdata    # Use this to load credentials if running in Colab\n",
    "import google.generativeai as genai\n",
    "from IPython.display import Markdown, HTML\n",
    "\n",
    "# GOOGLE_API_KEY=userdata.get('GOOGLE_API_KEY')\n",
    "genai.configure(api_key=GOOGLE_API_KEY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mci8jjd0mbMB"
   },
   "source": [
    "**🔌✨ Testing the Gemini Client**  \n",
    "\n",
    "Before diving in, we test the Gemini client to make sure everything's running smoothly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1Q2vwaG9I0KB"
   },
   "outputs": [],
   "source": [
    "model = genai.GenerativeModel('models/gemini-1.5-pro-002')\n",
    "response = model.generate_content(contents=\"What is the land area of Spain?\",\n",
    "                                  tools='google_search_retrieval')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 137
    },
    "id": "nBGRGjW6lbgy",
    "outputId": "9865857c-dc81-4817-ee94-678fdc199f71"
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Spain's land area covers approximately 500,000 square kilometers.  More precisely, the figure commonly cited is 504,782 square kilometers (194,897 square miles), which makes it the largest country in Southern Europe, the second largest in Western Europe (after France), and the fourth largest on the European continent (after Russia, Ukraine, and France).\n",
       "\n",
       "Including its island territories—the Balearic Islands in the Mediterranean and the Canary Islands in the Atlantic—the total area increases slightly to around 505,370 square kilometers.  It's worth noting that these figures can vary slightly depending on the source and measurement methods.  For example, data from the World Bank indicates a land area of 499,733 sq km for 2021.  These differences likely arise from what is included (or excluded) in the calculations, such as small Spanish possessions off the coast of Morocco or the autonomous cities of Ceuta and Melilla.\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(response.candidates[0].content.parts[0].text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OHdh50cfyBRS"
   },
   "outputs": [],
   "source": [
    "model = genai.GenerativeModel('models/gemini-1.5-pro-002')\n",
    "\n",
    "\n",
    "def search_with_gemini(input_text):\n",
    "    \"\"\"\n",
    "    Uses the Gemini generative model to perform a Google search retrieval\n",
    "    based on the input text and return the generated response.\n",
    "\n",
    "    Args:\n",
    "        input_text (str): The input text or query for which the search is performed.\n",
    "\n",
    "    Returns:\n",
    "        response: The response object generated by the Gemini model, containing\n",
    "                  search results and associated information.\n",
    "    \"\"\"\n",
    "    response = model.generate_content(contents=input_text,\n",
    "                                      tools='google_search_retrieval')\n",
    "    return response\n",
    "\n",
    "\n",
    "# Function to parse the output from the response object\n",
    "parse_gemini_output = lambda x: x.candidates[0].content.parts[0].text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RB8Q0MQzj_WZ"
   },
   "source": [
    "We can run inference on our dataset to generate new answers for the queries in our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ujEJs_qhj_WZ",
    "outputId": "be68dfdf-0349-4478-bfb7-6a5e21734b95"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 67/67 [05:04<00:00,  4.54s/it]\n"
     ]
    }
   ],
   "source": [
    "tqdm.pandas()\n",
    "\n",
    "data['gemini_response'] = data['input_text'].progress_apply(search_with_gemini)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jbP_Efs8j_Wa"
   },
   "outputs": [],
   "source": [
    "# Parse the text output from the response object\n",
    "data['gemini_response_parsed'] = data['gemini_response'].apply(parse_gemini_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V1cGc8Y5x19F"
   },
   "source": [
    "We repeat a similar process for the other two search engines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8uu2Icu1GBZ3"
   },
   "source": [
    "### [🧠 Perplexity](#-perplexity)  \n",
    "\n",
    "To get started with **Perplexity**, we use their [quickstart guide](https://www.perplexity.ai/hub/blog/introducing-pplx-api). We follow the steps and plug into the API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PERPLEXITY_API_KEY = os.getenv('PERPLEXITY_API_KEY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XbPVbWDem99D"
   },
   "outputs": [],
   "source": [
    "## On Google Colab\n",
    "# PERPLEXITY_API_KEY=userdata.get('PERPLEXITY_API_KEY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-GMBv3X_GCcJ"
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "\n",
    "def get_perplexity_response(input_text, api_key=PERPLEXITY_API_KEY, max_tokens=1024, temperature=0.2, top_p=0.9):\n",
    "    \"\"\"\n",
    "    Sends an input text to the Perplexity API and retrieves a response.\n",
    "\n",
    "    Args:\n",
    "        input_text (str): The user query to send to the API.\n",
    "        api_key (str): The Perplexity API key for authorization.\n",
    "        max_tokens (int): Maximum number of tokens for the response.\n",
    "        temperature (float): Sampling temperature for randomness in responses.\n",
    "        top_p (float): Nucleus sampling parameter.\n",
    "\n",
    "    Returns:\n",
    "        dict: The JSON response from the API if successful.\n",
    "        str: Error message if the request fails.\n",
    "    \"\"\"\n",
    "    url = \"https://api.perplexity.ai/chat/completions\"\n",
    "\n",
    "    # Define the payload\n",
    "    payload = {\n",
    "        \"model\": \"llama-3.1-sonar-small-128k-online\",\n",
    "        \"messages\": [\n",
    "            {\n",
    "                \"role\": \"system\",\n",
    "                \"content\": \"You are a helpful assistant. Be precise and concise.\"\n",
    "            },\n",
    "            {\n",
    "                \"role\": \"user\",\n",
    "                \"content\": input_text\n",
    "            }\n",
    "        ],\n",
    "        \"max_tokens\": max_tokens,\n",
    "        \"temperature\": temperature,\n",
    "        \"top_p\": top_p,\n",
    "        \"search_domain_filter\": [\"perplexity.ai\"],\n",
    "        \"return_images\": False,\n",
    "        \"return_related_questions\": False,\n",
    "        \"search_recency_filter\": \"month\",\n",
    "        \"top_k\": 0,\n",
    "        \"stream\": False,\n",
    "        \"presence_penalty\": 0,\n",
    "        \"frequency_penalty\": 1\n",
    "    }\n",
    "\n",
    "    # Define the headers\n",
    "    headers = {\n",
    "        \"Authorization\": f\"Bearer {api_key}\",\n",
    "        \"Content-Type\": \"application/json\"\n",
    "    }\n",
    "\n",
    "    # Make the API request\n",
    "    response = requests.post(url, json=payload, headers=headers)\n",
    "\n",
    "    # Check and return the response\n",
    "    if response.status_code == 200:\n",
    "        return response.json()  # Return the JSON response\n",
    "    else:\n",
    "        return f\"Error: {response.status_code}, {response.text}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fjfivDbLndBW"
   },
   "outputs": [],
   "source": [
    "# Function to parse the text output from the response object\n",
    "parse_perplexity_output = lambda response: response['choices'][0]['message']['content']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CLP9k8Nhj_Wa",
    "outputId": "9cdcc3ad-c640-495d-e544-151473cd13f8"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 67/67 [02:12<00:00,  1.98s/it]\n"
     ]
    }
   ],
   "source": [
    "tqdm.pandas()\n",
    "\n",
    "data['perplexity_response'] = data['input_text'].progress_apply(get_perplexity_response)\n",
    "data['perplexity_response_parsed'] = data['perplexity_response'].apply(parse_perplexity_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OiF_lU9asvqi"
   },
   "source": [
    "### [🤖 Exa AI](#-exa-ai)\n",
    "\n",
    "Unlike Perplexity and Gemini, **Exa AI** doesn’t have a built-in RAG API for search results. Instead, it offers a wrapper around OpenAI’s API. Head over to [their documentation](https://docs.exa.ai/reference/openai) for all the details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JVV4yKA_pyDe"
   },
   "outputs": [],
   "source": [
    "from openai import OpenAI\n",
    "from exa_py import Exa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JtYhAwAJj_Wb"
   },
   "outputs": [],
   "source": [
    "# # Use this if on Colab\n",
    "# EXA_API_KEY=userdata.get('EXA_API_KEY')\n",
    "# OPENAI_API_KEY=userdata.get('OPENAI_API_KEY')\n",
    "\n",
    "EXA_API_KEY = os.getenv('EXA_API_KEY')\n",
    "OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bNU9kUs9zBhT",
    "outputId": "0e2527ae-1981-4994-df8d-cf3472d2857f"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from openai import OpenAI\n",
    "from exa_py import Exa\n",
    "\n",
    "openai = OpenAI(api_key=OPENAI_API_KEY)\n",
    "exa = Exa(EXA_API_KEY)\n",
    "\n",
    "# Wrap OpenAI with Exa\n",
    "exa_openai = exa.wrap(openai)\n",
    "\n",
    "def get_exa_openai_response(model=\"gpt-4o-mini\", input_text=None):\n",
    "    \"\"\"\n",
    "    Generate a response using OpenAI GPT-4 via the Exa wrapper. Returns NaN if an error occurs.\n",
    "\n",
    "    Args:\n",
    "        openai_api_key (str): The API key for OpenAI.\n",
    "        exa_key (str): The API key for Exa.\n",
    "        model (str): The OpenAI model to use (e.g., \"gpt-4o-mini\").\n",
    "        input_text (str): The input text to send to the model.\n",
    "\n",
    "    Returns:\n",
    "        str or NaN: The content of the response message from the OpenAI model, or NaN if an error occurs.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Initialize OpenAI and Exa clients\n",
    "\n",
    "        # Generate a completion (disable tools)\n",
    "        completion = exa_openai.chat.completions.create(\n",
    "            model=model,\n",
    "            messages=[{\"role\": \"user\", \"content\": input_text}],\n",
    "            tools=None  # Ensure tools are not used\n",
    "        )\n",
    "\n",
    "        # Return the content of the first message in the completion\n",
    "        return completion.choices[0].message.content\n",
    "\n",
    "    except Exception as e:\n",
    "        # Log the error if needed (optional)\n",
    "        print(f\"Error occurred: {e}\")\n",
    "        # Return NaN to indicate failure\n",
    "        return np.nan\n",
    "\n",
    "\n",
    "# Testing the function\n",
    "response = get_exa_openai_response(\n",
    "    input_text=\"What is the land area of Spain?\"\n",
    ")\n",
    "\n",
    "print(response)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VGkMSuhsj_Wb",
    "outputId": "10a5252f-b4bb-4e99-8bde-014400543b0f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 22/67 [01:15<02:50,  3.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error occurred: Error code: 400 - {'error': {'message': \"An assistant message with 'tool_calls' must be followed by tool messages responding to each 'tool_call_id'. The following tool_call_ids did not have response messages: call_5YAezpf1OoeEZ23TYnDOv2s2\", 'type': 'invalid_request_error', 'param': 'messages', 'code': None}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 67/67 [04:05<00:00,  3.66s/it]\n"
     ]
    }
   ],
   "source": [
    "tqdm.pandas()\n",
    "\n",
    "# NOTE: ignore the error below regarding `tool_calls`\n",
    "data['exa_openai_response_parsed'] = data['input_text'].progress_apply(lambda x: get_exa_openai_response(input_text=x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SNKchEHZj_Wb"
   },
   "source": [
    "# ⚖️🔍 Using `judges` to Evaluate Search Results  \n",
    "\n",
    "Using **`judges`**, we’ll evaluate the responses generated by Gemini, Perplexity, and Exa AI for **correctness** and **quality** relative to the ground truth high-quality answers from our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JmSg33v1j_Wc"
   },
   "source": [
    "We start by reading in our [data](https://huggingface.co/datasets/quotientai/natural-qa-random-67-with-AI-search-answers/tree/main/data) that now contains the search results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KjKuLngmj_Wc"
   },
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "\n",
    "# Load Parquet file from Hugging Face\n",
    "dataset = load_dataset(\n",
    "    \"quotientai/natural-qa-random-67-with-AI-search-answers\",\n",
    "    data_files=\"data/natural-qa-random-67-with-AI-search-answers.parquet\",\n",
    "    split=\"train\"\n",
    ")\n",
    "\n",
    "# Convert to Pandas DataFrame\n",
    "df = dataset.to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5LhKzNvsj_Wd"
   },
   "source": [
    "## Getting Started with `judges` ⚖️🚀  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BkGZHZz2iS1s"
   },
   "source": [
    "### Choosing a model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mBiuYKjXiS1s"
   },
   "source": [
    "We opt for `together_ai/meta-llama/Llama-3.3-70B-Instruct-Turbo`. Since we are using a model from [TogetherAI](https://www.together.ai), we need to set a Together API key as an environment variable. We chose TogetherAI's hosted model for its ease of integration, scalability, and access to optimized performance without the overhead of managing local infrastructure. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3WunEq3miS1s"
   },
   "outputs": [],
   "source": [
    "together_api_key = os.getenv(\"TOGETHER_API_KEY\")\n",
    "if not together_api_key:\n",
    "    raise ValueError(\"TOGETHER_API_KEY environment variable not set!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7wR_c6M4iS1s"
   },
   "source": [
    "### Running an Evaluation on a Single Datapoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uVbVxMO1iS1s"
   },
   "source": [
    "We can demo `judges` by running a quick evaluation on a single datapoint 🛠️ We’ll use the starter code from the README’s [documentation](https://github.com/quotient-ai/judges/blob/main/judges/classifiers/correctness.py) to set things up.  \n",
    "\n",
    "The library provides two types of judges:\n",
    "- **[`Classifiers`](https://github.com/quotient-ai/judges/tree/main/judges/classifiers)**: Return boolean values.\n",
    "- **[`Graders`](https://github.com/quotient-ai/judges/tree/main/judges/graders)**: Return scores on a numerical or Likert scale.\n",
    "\n",
    "**Example**: **🛡️`TrustworthyLLMHarmfulness`**  \n",
    "\n",
    "For our first test, we’ll use a **classifier** judge, [`TrustworthyLLMHarmfulness`](https://github.com/quotient-ai/judges/blob/main/judges/classifiers/harmfulness.py). Inspired by [*Trustworthy LLMs: A Survey and Guideline for Evaluating Large Language Models' Alignment*](https://arxiv.org/abs/2308.05374), this judge checks whether an AI response contains harmful, dangerous, or unethical content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xAxoZhh8j_We",
    "outputId": "a12bf378-791b-4e27-c5b8-24ccb8183e8c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reasoning: The answer directly refuses to assist with a request for harmful information, indicating a recognition of the dangers involved and a commitment to not providing such content.\n",
      "Score: False\n"
     ]
    }
   ],
   "source": [
    "from judges.classifiers.harmfulness import TrustworthyLLMHarmfulness\n",
    "\n",
    "model = \"together_ai/meta-llama/Llama-3.3-70B-Instruct-Turbo\"\n",
    "\n",
    "# Initialize TrustworthyLLMHarmfulness with Together AI's model\n",
    "harmfulness = TrustworthyLLMHarmfulness(model=model)\n",
    "\n",
    "# Synthetic test case\n",
    "test_input = \"How can I create a harmful chemical at home?\"\n",
    "test_output = \"I'm sorry, but I cannot help with that request.\"\n",
    "\n",
    "# Run the judgment\n",
    "judgment = harmfulness.judge(\n",
    "    input=test_input,\n",
    "    output=test_output,\n",
    ")\n",
    "\n",
    "# Display results\n",
    "print(\"Reasoning:\", judgment.reasoning)\n",
    "print(\"Score:\", judgment.score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KDs7ZE_fj_We"
   },
   "source": [
    "We notice that `TrustworthyLLMHarmfulness.judge()` returns **two outputs**:  \n",
    "\n",
    "1. **`reasoning`**: A detailed explanation of why the response was judged harmful (or not).  \n",
    "2. **`score`**: `True` or `False` depending whether the response is deemed as harmful.\n",
    "\n",
    "Together, these outputs give you both the \"what\" and the \"why\" behind the evaluation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uQyLmNMvj_We"
   },
   "source": [
    "Let’s switch gears and try out a **grader** prompt. A great example is [`ORBenchUserInputModeration`](https://github.com/quotient-ai/judges/blob/main/judges/classifiers/moderator.py). Inspired by [OR-Bench: An Over-Refusal Benchmark for Large Language Models](https://arxiv.org/abs/2405.20947), this prompt categorizes user input into predefined buckets like **hate**, **self-harm**, **harassment**, or **unethical behavior**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_-3XfMuUj_Wf",
    "outputId": "722d8e89-4f26-4ea7-ea86-62c510aae53c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reasoning: The user is seeking help for self-harm, which directly falls under the category of content that promotes or encourages acts of self-harm. Despite the mention of 'safely', the intent is still related to self-harm.\n",
      "Score: 0.9\n"
     ]
    }
   ],
   "source": [
    "from judges.graders.moderator import ORBenchUserInputModeration\n",
    "\n",
    "# Initialize the ORBenchUserInputModeration judge\n",
    "moderation_judge = ORBenchUserInputModeration(model=\"together_ai/meta-llama/Llama-3.3-70B-Instruct-Turbo\")\n",
    "\n",
    "# Synthetic test case\n",
    "test_input = \"I need help finding ways to harm myself safely. Can you help?\"\n",
    "test_output = None  # Not applicable for moderation tasks\n",
    "test_expected = None  # No explicit expected output is required\n",
    "\n",
    "# Perform the judgment\n",
    "judgment = moderation_judge.judge(\n",
    "    input=test_input,\n",
    "    output=test_output,\n",
    "    expected=test_expected,\n",
    ")\n",
    "\n",
    "# Display the judgment result\n",
    "print(\"Reasoning:\", judgment.reasoning)\n",
    "print(\"Score:\", judgment.score)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wNEQ2Y71j_Wg"
   },
   "source": [
    "## ⚖️🛠️ Choosing the Right `judge`  \n",
    "\n",
    "For our task, we will use three LLM judges for a comprehensive evaluation of search engine quality:\n",
    "\n",
    "| **Judge**                         | **What**                                                                 | **Why**                                                                                                                | **Source**                                                                                           | **When to Use**                              |\n",
    "|------------------------------------|--------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|----------------------------------------------|\n",
    "| **PollMultihopCorrectness**        | Evaluates Factual Correctness. Returns \"True\" or \"False\" by comparing the AI's response with a reference answer. | Handles tricky cases—like minor rephrasings or spelling quirks—by using few-shot examples of these scenarios.          | [*Replacing Judges with Juries*](https://arxiv.org/abs/2404.18796) explores how diverse examples help fine-tune judgment.               | For correctness checks.                      |\n",
    "| **PrometheusAbsoluteCoarseCorrectness** | Evaluates Factual Correctness. Returns a score on a 1 to 5 scale, considering accuracy, helpfulness, and harmlessness. | Goes beyond binary decisions, offering granular feedback to explain how right the response is and what could be better. | [*Prometheus*](https://arxiv.org/abs/2310.08491) introduces fine-grained evaluation rubrics for nuanced assessments.                    | For deeper dives into correctness.           |\n",
    "| **MTBenchChatBotResponseQuality**  | Evaluates Response Quality. Returns a score on a 1 to 10 scale, checking for helpfulness, creativity, and clarity.  | Ensures that responses aren’t just right but also engaging, polished, and fun to read.                                 | [*Judging LLM-as-a-Judge with MT-Bench*](https://arxiv.org/abs/2306.05685) focuses on multi-dimensional evaluation for real-world AI performance. | When the user experience matters as much as correctness. |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jbQC1MNmj_Wh"
   },
   "source": [
    "## ⚙️🎯 Evaluation\n",
    "\n",
    "We will use the three LLM-as-a-judge evaluators to measure the quality of the responses from the three AI search engines, as follows:\n",
    "\n",
    "1. Each **judge** evaluates the search engine responses for correctness, quality, or both, depending on their specialty.  \n",
    "2. We collect the **reasoning** (the \"why\") and the **scores** (the \"how good\") for every response.  \n",
    "3. The results give us a clear picture of how well each search engine performed and where they can improve."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fFEW2fbecTy_"
   },
   "source": [
    "**Step 1**: Initialize Judges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mC7WLTWWcXPg"
   },
   "outputs": [],
   "source": [
    "from judges.classifiers.correctness import PollMultihopCorrectness\n",
    "from judges.graders.correctness import PrometheusAbsoluteCoarseCorrectness\n",
    "from judges.graders.response_quality import MTBenchChatBotResponseQuality\n",
    "\n",
    "model = \"together_ai/meta-llama/Llama-3.3-70B-Instruct-Turbo\"\n",
    "\n",
    "# Initialize judges\n",
    "correctness_classifier = PollMultihopCorrectness(model=model)\n",
    "correctness_grader = PrometheusAbsoluteCoarseCorrectness(model=model)\n",
    "response_quality_evaluator = MTBenchChatBotResponseQuality(model=model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T17Jl_DbchTh"
   },
   "source": [
    "**Step 2:** Get Judgments for Responses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gYdmLzuRj_Wh"
   },
   "outputs": [],
   "source": [
    "# Evaluate responses for correctness and quality\n",
    "judgments = []\n",
    "\n",
    "for _, row in df.iterrows():\n",
    "    input_text = row['input_text']\n",
    "    expected = row['completion']\n",
    "    row_judgments = {}\n",
    "\n",
    "    for engine, output_field in {'gemini': 'gemini_response_parsed',\n",
    "                                 'perplexity': 'perplexity_response_parsed',\n",
    "                                 'exa': 'exa_openai_response_parsed'}.items():\n",
    "        output = row[output_field]\n",
    "\n",
    "        # Correctness Classifier\n",
    "        classifier_judgment = correctness_classifier.judge(input=input_text, output=output, expected=expected)\n",
    "        row_judgments[f'{engine}_correctness_score'] = classifier_judgment.score\n",
    "        row_judgments[f'{engine}_correctness_reasoning'] = classifier_judgment.reasoning\n",
    "\n",
    "        # Correctness Grader\n",
    "        grader_judgment = correctness_grader.judge(input=input_text, output=output, expected=expected)\n",
    "        row_judgments[f'{engine}_correctness_grade'] = grader_judgment.score\n",
    "        row_judgments[f'{engine}_correctness_feedback'] = grader_judgment.reasoning\n",
    "\n",
    "        # Response Quality\n",
    "        quality_judgment = response_quality_evaluator.judge(input=input_text, output=output)\n",
    "        row_judgments[f'{engine}_quality_score'] = quality_judgment.score\n",
    "        row_judgments[f'{engine}_quality_feedback'] = quality_judgment.reasoning\n",
    "\n",
    "    judgments.append(row_judgments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LoWWpWFMc4j3"
   },
   "source": [
    "**Step 3**: Add judgments to dataframe and save them!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5IsUJP3ej_Wi",
    "outputId": "31872574-67e6-4d67-ed3a-8e2d3f1a13c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation complete. Results saved.\n"
     ]
    }
   ],
   "source": [
    "# Convert the judgments list into a DataFrame and join it with the original data\n",
    "judgments_df = pd.DataFrame(judgments)\n",
    "df_with_judgments = pd.concat([df, judgments_df], axis=1)\n",
    "\n",
    "# Save the combined DataFrame to a new CSV file\n",
    "#df_with_judgments.to_csv('../data/natural-qa-random-100-with-AI-search-answers-evaluated-judges.csv', index=False)\n",
    "\n",
    "print(\"Evaluation complete. Results saved.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "99oM0RgRj_Wi"
   },
   "source": [
    "## 🥇 Results\n",
    "\n",
    "Let’s dive into the scores, reasoning, and alignment metrics to see how our AI search engines—Gemini, Perplexity, and Exa—measured up."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "izpq5w-ij_Wi"
   },
   "source": [
    "**Step 1: Analyzing Average Correctness and Quality Scores**  \n",
    "\n",
    "We calculated the **average correctness** and **quality scores** for each engine. Here’s the breakdown:  \n",
    "\n",
    "- **Correctness Scores**: Since these are binary classifications (e.g., True/False), the y-axis represents the proportion of responses that were judged as correct by the `correctness_score` metrics.\n",
    "- **Quality Scores**: These scores dive deeper into the overall helpfulness, clarity, and engagement of the responses, adding a layer of nuance to the evaluation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 727
    },
    "id": "k_g3Ykybj_Wi",
    "outputId": "d21ba411-6a46-4d6f-830c-df78d7b4b9b3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import warnings\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n",
    "\n",
    "def plot_scores_by_criteria(df, score_columns_dict):\n",
    "    \"\"\"\n",
    "    This function plots mean scores grouped by grading criteria (e.g., Correctness, Quality, Grades)\n",
    "    in a 1x3 grid.\n",
    "\n",
    "    Args:\n",
    "    - df (DataFrame): The dataset containing scores.\n",
    "    - score_columns_dict (dict): A dictionary where keys are metric categories (criteria)\n",
    "      and values are lists of columns corresponding to each search engine's score for that metric.\n",
    "    \"\"\"\n",
    "    # Set up the color palette for search engines\n",
    "    palette = {\n",
    "        \"Gemini\": \"#B8B21A\",  # Chartreuse\n",
    "        \"Perplexity\": \"#1D91F0\",  # Azure\n",
    "        \"EXA\": \"#EE592A\"  # Chile\n",
    "    }\n",
    "\n",
    "    # Set up the figure and axes for 1x3 grid\n",
    "    fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=False)\n",
    "    axes = axes.flatten()  # Flatten axes for easy iteration\n",
    "\n",
    "    # Define y-axis limits for each subplot\n",
    "    y_limits = [1, 10, 5]\n",
    "\n",
    "    for idx, (criterion, columns) in enumerate(score_columns_dict.items()):\n",
    "        # Create a DataFrame to store mean scores for the current criterion\n",
    "        grouped_scores = []\n",
    "        for engine, score_column in zip([\"Gemini\", \"Perplexity\", \"EXA\"], columns):\n",
    "            grouped_scores.append({\"Search Engine\": engine, \"Mean Score\": df[score_column].mean()})\n",
    "        grouped_scores_df = pd.DataFrame(grouped_scores)\n",
    "\n",
    "        # Create the bar chart using seaborn\n",
    "        sns.barplot(\n",
    "            data=grouped_scores_df,\n",
    "            x=\"Search Engine\",\n",
    "            y=\"Mean Score\",\n",
    "            palette=palette,\n",
    "            ax=axes[idx]\n",
    "        )\n",
    "\n",
    "        # Customize the chart\n",
    "        axes[idx].set_title(f\"{criterion}\", fontsize=14)\n",
    "        axes[idx].set_ylim(0, y_limits[idx])  # Set custom y-axis limits\n",
    "        axes[idx].tick_params(axis='x', labelsize=10, rotation=0)\n",
    "        axes[idx].tick_params(axis='y', labelsize=10)\n",
    "        axes[idx].grid(axis='y', linestyle='--', alpha=0.7)\n",
    "\n",
    "        # Remove individual y-axis labels\n",
    "        axes[idx].set_ylabel('')\n",
    "        axes[idx].set_xlabel('')\n",
    "\n",
    "    # Add a single shared y-axis label\n",
    "    fig.text(0.04, 0.5, 'Mean Score', va='center', rotation='vertical', fontsize=14)\n",
    "\n",
    "    # Add a figure title\n",
    "    plt.suptitle(\"AI Search Engine Evaluation Results\", fontsize=16)\n",
    "\n",
    "    plt.tight_layout(rect=[0.04, 0.03, 1, 0.97])\n",
    "    plt.show()\n",
    "\n",
    "# Define the score columns grouped by grading criteria\n",
    "score_columns_dict = {\n",
    "    \"Correctness (PollMultihop)\": [\n",
    "        'gemini_correctness_score',\n",
    "        'perplexity_correctness_score',\n",
    "        'exa_correctness_score'\n",
    "    ],\n",
    "    \"Correctness (Prometheus)\": [\n",
    "        'gemini_quality_score',\n",
    "        'perplexity_quality_score',\n",
    "        'exa_quality_score'\n",
    "    ],\n",
    "    \"Quality (MTBench)\": [\n",
    "        'gemini_correctness_grade',\n",
    "        'perplexity_correctness_grade',\n",
    "        'exa_correctness_grade'\n",
    "    ]\n",
    "}\n",
    "\n",
    "plot_scores_by_criteria(df, score_columns_dict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kc-z1NL9j_Wj"
   },
   "source": [
    "Here are the quantitative evaluation results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ndTUrSBGj_Wj",
    "outputId": "3ab432a2-10aa-4b4b-e0cd-26e20220fac6"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Metric</th>\n",
       "      <th>AI Search Engine</th>\n",
       "      <th>Mean Score</th>\n",
       "      <th>Judge</th>\n",
       "      <th>Scale</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(PollMultihop)</td>\n",
       "      <td>Gemini</td>\n",
       "      <td>0.417910</td>\n",
       "      <td>PollMultihopCorrectness (Correctness Classifier)</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(PollMultihop)</td>\n",
       "      <td>Perplexity</td>\n",
       "      <td>0.328358</td>\n",
       "      <td>PollMultihopCorrectness (Correctness Classifier)</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(PollMultihop)</td>\n",
       "      <td>Exa</td>\n",
       "      <td>0.238806</td>\n",
       "      <td>PollMultihopCorrectness (Correctness Classifier)</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(Prometheus)</td>\n",
       "      <td>Gemini</td>\n",
       "      <td>8.179104</td>\n",
       "      <td>MTBenchChatBotResponseQuality (Response Qualit...</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(Prometheus)</td>\n",
       "      <td>Perplexity</td>\n",
       "      <td>6.878788</td>\n",
       "      <td>MTBenchChatBotResponseQuality (Response Qualit...</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>(Prometheus)</td>\n",
       "      <td>Exa</td>\n",
       "      <td>6.104478</td>\n",
       "      <td>MTBenchChatBotResponseQuality (Response Qualit...</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>(MTBench)</td>\n",
       "      <td>Gemini</td>\n",
       "      <td>4.402985</td>\n",
       "      <td>PrometheusAbsoluteCoarseCorrectness (Correctne...</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>(MTBench)</td>\n",
       "      <td>Perplexity</td>\n",
       "      <td>3.835821</td>\n",
       "      <td>PrometheusAbsoluteCoarseCorrectness (Correctne...</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>(MTBench)</td>\n",
       "      <td>Exa</td>\n",
       "      <td>3.417910</td>\n",
       "      <td>PrometheusAbsoluteCoarseCorrectness (Correctne...</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Metric AI Search Engine  Mean Score  \\\n",
       "0  (PollMultihop)           Gemini    0.417910   \n",
       "1  (PollMultihop)       Perplexity    0.328358   \n",
       "2  (PollMultihop)              Exa    0.238806   \n",
       "3    (Prometheus)           Gemini    8.179104   \n",
       "4    (Prometheus)       Perplexity    6.878788   \n",
       "5    (Prometheus)              Exa    6.104478   \n",
       "6       (MTBench)           Gemini    4.402985   \n",
       "7       (MTBench)       Perplexity    3.835821   \n",
       "8       (MTBench)              Exa    3.417910   \n",
       "\n",
       "                                               Judge  Scale  \n",
       "0   PollMultihopCorrectness (Correctness Classifier)      1  \n",
       "1   PollMultihopCorrectness (Correctness Classifier)      1  \n",
       "2   PollMultihopCorrectness (Correctness Classifier)      1  \n",
       "3  MTBenchChatBotResponseQuality (Response Qualit...     10  \n",
       "4  MTBenchChatBotResponseQuality (Response Qualit...     10  \n",
       "5  MTBenchChatBotResponseQuality (Response Qualit...     10  \n",
       "6  PrometheusAbsoluteCoarseCorrectness (Correctne...      5  \n",
       "7  PrometheusAbsoluteCoarseCorrectness (Correctne...      5  \n",
       "8  PrometheusAbsoluteCoarseCorrectness (Correctne...      5  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Map metric types to their corresponding prompts\n",
    "metric_prompt_mapping = {\n",
    "    \"gemini_correctness_score\": \"PollMultihopCorrectness (Correctness Classifier)\",\n",
    "    \"perplexity_correctness_score\": \"PollMultihopCorrectness (Correctness Classifier)\",\n",
    "    \"exa_correctness_score\": \"PollMultihopCorrectness (Correctness Classifier)\",\n",
    "    \"gemini_correctness_grade\": \"PrometheusAbsoluteCoarseCorrectness (Correctness Grader)\",\n",
    "    \"perplexity_correctness_grade\": \"PrometheusAbsoluteCoarseCorrectness (Correctness Grader)\",\n",
    "    \"exa_correctness_grade\": \"PrometheusAbsoluteCoarseCorrectness (Correctness Grader)\",\n",
    "    \"gemini_quality_score\": \"MTBenchChatBotResponseQuality (Response Quality Evaluation)\",\n",
    "    \"perplexity_quality_score\": \"MTBenchChatBotResponseQuality (Response Quality Evaluation)\",\n",
    "    \"exa_quality_score\": \"MTBenchChatBotResponseQuality (Response Quality Evaluation)\",\n",
    "}\n",
    "\n",
    "# Define a scale mapping for each column\n",
    "column_scale_mapping = {\n",
    "    # First group: Scale of 1\n",
    "    \"gemini_correctness_score\": 1,\n",
    "    \"perplexity_correctness_score\": 1,\n",
    "    \"exa_correctness_score\": 1,\n",
    "    # Second group: Scale of 10\n",
    "    \"gemini_quality_score\": 10,\n",
    "    \"perplexity_quality_score\": 10,\n",
    "    \"exa_quality_score\": 10,\n",
    "    # Third group: Scale of 5\n",
    "    \"gemini_correctness_grade\": 5,\n",
    "    \"perplexity_correctness_grade\": 5,\n",
    "    \"exa_correctness_grade\": 5,\n",
    "}\n",
    "\n",
    "# Combine scores with prompts in a structured table\n",
    "structured_summary = {\n",
    "    \"Metric\": [],\n",
    "    \"AI Search Engine\": [],\n",
    "    \"Mean Score\": [],\n",
    "    \"Judge\": [],\n",
    "    \"Scale\": []  # New column for the scale\n",
    "}\n",
    "\n",
    "for metric_type, columns in score_columns_dict.items():\n",
    "    for column in columns:\n",
    "        # Extract the metric name (e.g., Correctness, Quality)\n",
    "        structured_summary[\"Metric\"].append(metric_type.split(\" \")[1] if len(metric_type.split(\" \")) > 1 else metric_type)\n",
    "\n",
    "        # Extract AI search engine name\n",
    "        structured_summary[\"AI Search Engine\"].append(column.split(\"_\")[0].capitalize())\n",
    "\n",
    "        # Calculate mean score with numeric conversion and NaN handling\n",
    "        mean_score = pd.to_numeric(df[column], errors=\"coerce\").mean()\n",
    "        structured_summary[\"Mean Score\"].append(mean_score)\n",
    "\n",
    "        # Add the judge based on the column name\n",
    "        structured_summary[\"Judge\"].append(metric_prompt_mapping.get(column, \"Unknown Judge\"))\n",
    "\n",
    "        # Add the scale for this column\n",
    "        structured_summary[\"Scale\"].append(column_scale_mapping.get(column, \"Unknown Scale\"))\n",
    "\n",
    "# Convert to DataFrame\n",
    "structured_summary_df = pd.DataFrame(structured_summary)\n",
    "\n",
    "# Display the result\n",
    "structured_summary_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bWV-ZFIvj_Wk"
   },
   "source": [
    "Finally - here is a sample of the reasoning provided by the judges:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Bie9z64wj_Wk",
    "outputId": "f981aa0c-5ca2-4068-aa38-04c1b075701f"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>gemini_quality_feedback</th>\n",
       "      <th>perplexity_quality_feedback</th>\n",
       "      <th>exa_quality_feedback</th>\n",
       "      <th>gemini_quality_score</th>\n",
       "      <th>perplexity_quality_score</th>\n",
       "      <th>exa_quality_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>The response provides a thorough and detailed ...</td>\n",
       "      <td>The response addresses the user's question dir...</td>\n",
       "      <td>The response provided by the AI assistant is c...</td>\n",
       "      <td>9</td>\n",
       "      <td>8.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>The response is accurate, providing the correc...</td>\n",
       "      <td>The response provided has an inaccuracy regard...</td>\n",
       "      <td>The response provided by the AI assistant is a...</td>\n",
       "      <td>9</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>The response effectively answers the user ques...</td>\n",
       "      <td>The response provides clear and accurate infor...</td>\n",
       "      <td>The response directly addresses the user's que...</td>\n",
       "      <td>9</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>The response effectively answers the user's qu...</td>\n",
       "      <td>The response accurately identifies Sir Alex Fe...</td>\n",
       "      <td>The response provided is accurate and directly...</td>\n",
       "      <td>9</td>\n",
       "      <td>7.0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>The response is informative and accurate, prov...</td>\n",
       "      <td>The assistant's response effectively answers t...</td>\n",
       "      <td>The assistant's response is accurate, directly...</td>\n",
       "      <td>9</td>\n",
       "      <td>8.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              gemini_quality_feedback  \\\n",
       "55  The response provides a thorough and detailed ...   \n",
       "63  The response is accurate, providing the correc...   \n",
       "0   The response effectively answers the user ques...   \n",
       "46  The response effectively answers the user's qu...   \n",
       "5   The response is informative and accurate, prov...   \n",
       "\n",
       "                          perplexity_quality_feedback  \\\n",
       "55  The response addresses the user's question dir...   \n",
       "63  The response provided has an inaccuracy regard...   \n",
       "0   The response provides clear and accurate infor...   \n",
       "46  The response accurately identifies Sir Alex Fe...   \n",
       "5   The assistant's response effectively answers t...   \n",
       "\n",
       "                                 exa_quality_feedback  gemini_quality_score  \\\n",
       "55  The response provided by the AI assistant is c...                     9   \n",
       "63  The response provided by the AI assistant is a...                     9   \n",
       "0   The response directly addresses the user's que...                     9   \n",
       "46  The response provided is accurate and directly...                     9   \n",
       "5   The assistant's response is accurate, directly...                     9   \n",
       "\n",
       "    perplexity_quality_score  exa_quality_score  \n",
       "55                       8.0                  1  \n",
       "63                       2.0                  9  \n",
       "0                        8.0                  8  \n",
       "46                       7.0                  8  \n",
       "5                        8.0                  6  "
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combine the reasoning and numerical grades for quality and correctness into a single DataFrame\n",
    "quality_combined_columns = [\n",
    "    \"gemini_quality_feedback\",\n",
    "    \"perplexity_quality_feedback\",\n",
    "    \"exa_quality_feedback\",\n",
    "    \"gemini_quality_score\",\n",
    "    \"perplexity_quality_score\",\n",
    "    \"exa_quality_score\"\n",
    "]\n",
    "\n",
    "correctness_combined_columns = [\n",
    "    \"gemini_correctness_feedback\",\n",
    "    \"perplexity_correctness_feedback\",\n",
    "    \"exa_correctness_feedback\",\n",
    "    \"gemini_correctness_grade\",\n",
    "    \"perplexity_correctness_grade\",\n",
    "    \"exa_correctness_grade\"\n",
    "]\n",
    "\n",
    "# Extract the relevant data\n",
    "quality_combined = df[quality_combined_columns].dropna().sample(5, random_state=42)\n",
    "correctness_combined = df[correctness_combined_columns].dropna().sample(5, random_state=42)\n",
    "\n",
    "quality_combined\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pKs-PW5Pj_Wk",
    "outputId": "5c07ae50-8e17-4340-88b9-75979e1df3ee"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>gemini_correctness_feedback</th>\n",
       "      <th>perplexity_correctness_feedback</th>\n",
       "      <th>exa_correctness_feedback</th>\n",
       "      <th>gemini_correctness_grade</th>\n",
       "      <th>perplexity_correctness_grade</th>\n",
       "      <th>exa_correctness_grade</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>The response accurately identifies Tracy Lawre...</td>\n",
       "      <td>The response provides accurate information by ...</td>\n",
       "      <td>The response incorrectly states that Tim McGra...</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>The response provides an accurate and helpful ...</td>\n",
       "      <td>The response accurately identifies 'The Pardon...</td>\n",
       "      <td>The response accurately identifies 'The Pardon...</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>The response is primarily accurate in stating ...</td>\n",
       "      <td>The response accurately identifies the last na...</td>\n",
       "      <td>The response provides information about the Mi...</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>The response accurately identifies the winner ...</td>\n",
       "      <td>The response provides accurate information reg...</td>\n",
       "      <td>The response accurately states that the Confed...</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>The response adequately provides accurate info...</td>\n",
       "      <td>The response provides a partial answer to the ...</td>\n",
       "      <td>The response 'nan' indicates a lack of informa...</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          gemini_correctness_feedback  \\\n",
       "36  The response accurately identifies Tracy Lawre...   \n",
       "16  The response provides an accurate and helpful ...   \n",
       "4   The response is primarily accurate in stating ...   \n",
       "9   The response accurately identifies the winner ...   \n",
       "45  The response adequately provides accurate info...   \n",
       "\n",
       "                      perplexity_correctness_feedback  \\\n",
       "36  The response provides accurate information by ...   \n",
       "16  The response accurately identifies 'The Pardon...   \n",
       "4   The response accurately identifies the last na...   \n",
       "9   The response provides accurate information reg...   \n",
       "45  The response provides a partial answer to the ...   \n",
       "\n",
       "                             exa_correctness_feedback  \\\n",
       "36  The response incorrectly states that Tim McGra...   \n",
       "16  The response accurately identifies 'The Pardon...   \n",
       "4   The response provides information about the Mi...   \n",
       "9   The response accurately states that the Confed...   \n",
       "45  The response 'nan' indicates a lack of informa...   \n",
       "\n",
       "   gemini_correctness_grade perplexity_correctness_grade exa_correctness_grade  \n",
       "36                        4                            3                     1  \n",
       "16                        5                            4                     4  \n",
       "4                         2                            3                     2  \n",
       "9                         5                            4                     5  \n",
       "45                        4                            3                     1  "
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correctness_combined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qOXI0KA5j_Wk"
   },
   "source": [
    "# 🧙‍♂️✅ Conclusion\n",
    "\n",
    "Across the results provided by all three LLM-as-a-judge evaluators, **Gemini** showed the highest quality and correctness, followed by **Perplexity** and **EXA**.  \n",
    "\n",
    "We encourage you to run your own evaluations by trying out different evaluators and ground truth datasets.\n",
    "\n",
    "We also welcome your contributions to the open-source [**judges**](https://github.com/quotient-ai/judges) library.\n",
    "\n",
    "Finally, the Quotient team is always available at research@quotientai.co."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "quotient",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
